<?php

class KDomain
{
  
  protected $id = 0;
  protected $name = '';
  
  protected $childs = array();
  protected $parent = NULL; 
   
  
  
  public function GetId()
  {
  	return $this->id;
  }
  
  
  public function GetName()
  {
    return $this->name;
  }
  
  
  public function GetChilds()
  {
    return $this->childs;
  }
  
  
  public function GetParent()
  {
  	return $this->parent;
  }
  
  
  
  public function __construct($id=0, $parent=NULL)
  {
    $this->id = $id;
    $this->parent = $parent; 
    $this->initFromDb();
  }
  
  
  
  //TODO: Diese Funktion kann sehr viele Datenbankverbindungen gleichzeitig öffnen, oder?
  protected function initFromDb()
  {
  	$db = DB::getMysqli();
  	
  	//Wenn keine Id übergeben wird, werden die Kategorien der obersten Ebene rekursiv initialisiert
  	if ($this->GetId() == 0)
  	{
  	  $queryStr = 'SELECT
                     id
                   FROM
                     kdomains
                   WHERE
                     parent <=> NULL;';
  	  $result = $db->query($queryStr);
  	  while ($row = $result->fetch_assoc())
  	  {
  	    //Dieser Workaround scheint notwendig, da Polymorphie nicht richtig unterstützt wird
  	  	if (get_class($this) == 'KDomain')
  	  	{
  	  	  KDomain::AddChild(NULL, (int)$row['id'], $this);
  	  	}
  	  	else if (get_class($this) == 'UserKDomain')
  	  	{
  	  	  UserKDomain::AddChild(NULL, (int)$row['id'], $this);
  	  	}
  	  }
  	}
  	//Wenn eine Id übergeben wurde...
  	else
  	{
  	  $queryStr = 'SELECT
                     *
                   FROM
	                 kdomains
	               WHERE
	                 id = '.$this->GetId().';';
  	  $result = $db->query($queryStr);
  	  $row = $result->fetch_assoc();
  	  $this->name = $row['name'];
  	  
  	  //Initialisiert alle Kinder rekursiv
      $queryStr = 'SELECT
                     *
                   FROM
                     kdomains
                   WHERE
                     parent = '.$this->GetId().';';
      $result = $db->query($queryStr);
  	  while ($row = $result->fetch_assoc())
      {
        //Dieser Workaround scheint notwendig, da Polymorphie nicht richtig unterstützt wird
  	  	if (get_class($this) == 'KDomain')
  	  	{
  	  	  KDomain::AddChild(NULL, $row['id'], $this);
  	  	}
  	  	else if (get_class($this) == 'UserKDomain')
  	  	{
  	  	  UserKDomain::AddChild(NULL, $row['id'], $this);
  	  	}
      }
  	}
  	
  	//Am Ende wird die Datenbankverbindung ordnungsgemäß geschlossen
  	$result->close();
  }
  
  
  
  //Wird erstmal nicht benutzt, da Überladung nicht möglich ist
  /*
  public function AddChild($child)
  {
    array_push($this->childs, $child);
  }
  */
  
  
  
  //Diese Überladung existiert, damit UserKDomain diese Methode überschreiben und somit 
  //die Kinder als UserKDomain statt KDomain initiialisieren darf
  //TODO: Anpassen an UserKDomain::AddChild 
  public function AddChild($id, $parent)
  {
    echo "KDomain::AddChild()\r\n";
    //array_push($this->childs, new KDomain($id, $parent));
  }
  
  
  
  //Diese Funktion ist ähnlich der RemoveTag()-Funktion in Question aufgebaut
  //Sie durchsucht rekursiv alle Kinderelemente in diesem KDomain-Objekt und
  //löscht sie, wenn ihre ID mit der gesuchten übereinstimmt
  public function RemoveChild($childId)
  {
    //Erst wird ein leeres Array instantiiert
    $foundPos = array();
    //Dann werden alle Kindelemente durchgegangen
    foreach ($this->childs as $key => $currChild)
    {
      //Sollte die ID des Kindelementes mit der des gesuchten übereinstimmen, wird die Position zu
      //Löschliste hinzugefügt 
      if ($currChild->GetId == $childId)
      {
        $foundPos[] = $key;
      }
      //Anschließend wird auf dem Kind die gleiche Funktion wieder rekursiv aufgerufen.
      $currChild->RemoveChild($childId);
    }
    //Im Anschluss werden die gesuchten Kindelemente aus dem childs-Array gelöscht
    foreach ($foundPos as $key)
    {
      unset($this->childs[$key]);
      //DB::RemoveChild()
    }
  }

  
  
  //Durchsucht die gegebene KDomainstruktur nach einer KDomain mit der id childId
  // und gibt diese wenn gefunden zurück 
  public function SearchChild($childId)
  {
    //Wenn die aktuelle kDomain die gesuchte ist, wird diese zurückgegeben
  	if ($this->GetId() == $childId)
  	{
      return $this;
  	}
  	//Ansonsten werden alle Kinder durchsucht...
    foreach ($this->childs as $child)
    {
      //...indem diese Funktion rekursiv aufgerufen wird. 
      $searchResult = $child->SearchChild($childId); 
      //Wenn das Kind ein Ergebnis ungliehc null meldet, ist die gesuchte kDomain gefunden.
      if (!is_null($searchResult))
      {
        return $searchResult;
      }
    }
    //Wurden ale Kinder ohne Ergebnis durchsucht, wird NULL zurückgegeben
  	return NULL;
  }
  	
  	
  
}

?>